home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.004 / xemacs-1 / xemacs-19.13 / src / doc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-07  |  21.2 KB  |  784 lines
  1. /* Record indices of function doc strings stored in a file.
  2.    Copyright (C) 1985, 1986, 1992, 1993, 1994 Free Software Foundation, Inc.
  3.  
  4. This file is part of XEmacs.
  5.  
  6. XEmacs is free software; you can redistribute it and/or modify it
  7. under the terms of the GNU General Public License as published by the
  8. Free Software Foundation; either version 2, or (at your option) any
  9. later version.
  10.  
  11. XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14. for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with XEmacs; see the file COPYING.  If not, write to the Free
  18. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* Synched up with: FSF 19.28. */
  21.  
  22. /* This file has been Mule-ized except as noted. */
  23.  
  24. #include <config.h>
  25. #include "lisp.h"
  26.  
  27. #include "buffer.h"
  28. #include "bytecode.h"
  29. #include "insdel.h"
  30. #include "keymap.h"
  31.  
  32. #include "sysfile.h"
  33.  
  34.  
  35. Lisp_Object Vdoc_file_name;
  36.  
  37. static Lisp_Object
  38. get_doc_string (long filepos)
  39. {
  40.   /* !!#### This function has not been Mule-ized */
  41.   char buf[512 * 32 + 1];
  42.   REGISTER int fd;
  43.   REGISTER char *name;
  44.   REGISTER char *p, *p1;
  45.   REGISTER int count;
  46.  
  47.   if (!STRINGP (Vdoc_directory)
  48.       || !STRINGP (Vdoc_file_name))
  49.     return Qnil;
  50.  
  51.   name = (char *) alloca (string_length (XSTRING (Vdoc_directory))
  52.               + string_length (XSTRING (Vdoc_file_name))
  53.                           + 8);
  54.   strcpy (name, (char *) string_data (XSTRING (Vdoc_directory)));
  55.   strcat (name, (char *) string_data (XSTRING (Vdoc_file_name)));
  56. #ifdef VMS
  57. #ifndef VMS4_4
  58.   /* For VMS versions with limited file name syntax,
  59.      convert the name to something VMS will allow.  */
  60.   p = name;
  61.   while (*p)
  62.     {
  63.       if (*p == '-')
  64.     *p = '_';
  65.       p++;
  66.     }
  67. #endif /* not VMS4_4 */
  68. #ifdef VMS4_4
  69.   strcpy (name, sys_translate_unix (name));
  70. #endif /* VMS4_4 */
  71. #endif /* VMS */
  72.  
  73.   fd = open (name, O_RDONLY, 0);
  74.   if (fd < 0)
  75.     error ("Cannot open doc string file \"%s\"", name);
  76.   if (0 > lseek (fd, filepos, 0))
  77.     {
  78.       close (fd);
  79.       error ("Position %ld out of range in doc string file \"%s\"",
  80.          filepos, name);
  81.     }
  82.   p = buf;
  83.   while (p != buf + sizeof buf - 1)
  84.     {
  85.       count = read (fd, p, 512);
  86.       p[count] = 0;
  87.       if (!count)
  88.     break;
  89.       p1 = strchr (p, '\037');
  90.       if (p1)
  91.     {
  92.       *p1 = 0;
  93.       p = p1;
  94.       break;
  95.     }
  96.       p += count;
  97.     }
  98.   close (fd);
  99.   return make_string ((Bufbyte *) buf, p - buf);
  100. }
  101.  
  102. DEFUN ("documentation", Fdocumentation, Sdocumentation, 1, 2, 0,
  103.   "Return the documentation string of FUNCTION.\n\
  104. Unless a non-nil second argument is given, the\n\
  105. string is passed through `substitute-command-keys'.")
  106.   (function, raw)
  107.      Lisp_Object function, raw;
  108. {
  109.   /* This function can GC */
  110.   Lisp_Object fun;
  111.   Lisp_Object doc;
  112.  
  113.   fun = Findirect_function (function);
  114.   if (SUBRP (fun))
  115.     {
  116.       if (XSUBR (fun)->doc == 0)
  117.     return (Qnil);
  118.       else if ((LISP_WORD_TYPE) XSUBR (fun)->doc >= 0)
  119.     doc = build_string (XSUBR (fun)->doc);
  120.       else
  121.         doc = get_doc_string (- (long) XSUBR (fun)->doc);
  122.     }
  123.   else if (BYTECODEP (fun))
  124.     {
  125.       Lisp_Object tem;
  126.       struct Lisp_Bytecode *b = XBYTECODE (fun);
  127.       if (! (b->flags.documentationp))
  128.         return (Qnil);
  129.       tem = bytecode_documentation (b);
  130.       if (STRINGP (tem))
  131.     doc = tem;
  132.       else if (INTP (tem) && XINT (tem) >= 0)
  133.     doc = get_doc_string ((long) XINT (tem));
  134.       else
  135.         return (Qnil);
  136.     }
  137.   else if (KEYMAPP (fun))
  138.     return build_translated_string ("Prefix command (definition is a keymap of subcommands).");
  139.   else if (STRINGP (fun) || VECTORP (fun))
  140.     return build_translated_string ("Keyboard macro.");
  141.   else if (!CONSP (fun))
  142.     return Fsignal (Qinvalid_function, list1 (fun));
  143.   else
  144.     {
  145.       Lisp_Object funcar = Fcar (fun);
  146.  
  147.       if (!SYMBOLP (funcar))
  148.     return Fsignal (Qinvalid_function, list1 (fun));
  149.       else if (EQ (funcar, Qlambda)
  150.              || EQ (funcar, Qautoload))
  151.     {
  152.       Lisp_Object tem = Fcar (Fcdr (Fcdr (fun)));
  153.       if (STRINGP (tem))
  154.         doc = tem;
  155.       else if (INTP (tem) && XINT (tem) >= 0)
  156.         doc = get_doc_string ((long) XINT (tem));
  157.       else
  158.         return (Qnil);
  159.     }
  160. #ifdef MOCKLISP_SUPPORT
  161.     else if (XSYMBOL (funcar) == XSYMBOL (Qmocklisp))
  162.       return (Qnil);
  163. #endif
  164.     else if (XSYMBOL (funcar) == XSYMBOL (Qmacro))
  165.       return (Fdocumentation (Fcdr (fun), raw));
  166.     else
  167.       return Fsignal (Qinvalid_function, list1 (fun));
  168.   }
  169.  
  170.   if (NILP (raw))
  171.     {
  172.       struct gcpro gcpro1;
  173. #ifdef I18N3
  174.       Lisp_Object domain = Qnil;
  175.       if (BYTECODEP (fun))
  176.     domain = Fcompiled_function_domain (fun);
  177.       if (NILP (domain))
  178.     doc = Fgettext (doc);
  179.       else
  180.     doc = Fdgettext (domain, doc);
  181. #endif
  182.  
  183.       GCPRO1 (doc);
  184.       doc = Fsubstitute_command_keys (doc);
  185.       UNGCPRO;
  186.     }
  187.   return (doc);
  188. }
  189.  
  190. DEFUN ("documentation-property", Fdocumentation_property, 
  191.        Sdocumentation_property, 2, 3, 0,
  192.   "Return the documentation string that is SYMBOL's PROP property.\n\
  193. This is like `get', but it can refer to strings stored in the\n\
  194. `exec-directory/DOC' file; and if the value is a string, it is passed\n\
  195. through `substitute-command-keys'.  A non-nil third argument avoids this\n\
  196. translation.")
  197.   (sym, prop, raw)
  198.      Lisp_Object sym, prop, raw;
  199. {
  200.   /* This function can GC */
  201.   REGISTER Lisp_Object doc;
  202. #ifdef I18N3
  203.   REGISTER Lisp_Object domain;
  204. #endif
  205.  
  206.   doc = Fget (sym, prop, Qnil);
  207.   if (INTP (doc))
  208.     doc = get_doc_string ((long) ((XINT (doc) > 0)
  209.                                   ? XINT (doc) : 
  210.                                   - XINT (doc)));
  211. #ifdef I18N3
  212.   if (!NILP (doc))
  213.     {
  214.       domain = Fget (sym, Qvariable_domain, Qnil);
  215.       if (NILP (domain))
  216.     doc = Fgettext (doc);
  217.       else
  218.     doc = Fdgettext (domain, doc);
  219.     }
  220. #endif    
  221.   if (NILP (raw) && STRINGP (doc))
  222.     doc = Fsubstitute_command_keys (doc);
  223.   return (doc);
  224. }
  225.  
  226. static void
  227. weird_doc (Lisp_Object sym, CONST char *weirdness, CONST char *type, int pos)
  228. {
  229. #ifdef ENERGIZE /* hide kludgery... */
  230.   if (!strcmp (weirdness, GETTEXT ("duplicate"))) return;
  231. #endif
  232.   message ("Note: Strange doc (%s) for %s %s @ %d",
  233.            weirdness, type, string_data (XSYMBOL (sym)->name), pos);
  234. }
  235.  
  236.  
  237. DEFUN ("Snarf-documentation", Fsnarf_documentation, Ssnarf_documentation,
  238.   1, 1, 0,
  239.   "Used during Emacs initialization, before dumping runnable Emacs,\n\
  240. to find pointers to doc strings stored in `.../lib-src/DOC' and\n\
  241. record them in function definitions.\n\
  242. One arg, FILENAME, a string which does not include a directory.\n\
  243. The file is written to `../lib-src', and later found in `exec-directory'\n\
  244. when doc strings are referred to in the dumped Emacs.")
  245.   (filename)
  246.      Lisp_Object filename;
  247. {
  248.   /* !!#### This function has not been Mule-ized */
  249.   int fd;
  250.   char buf[1024 + 1];
  251.   REGISTER int filled;
  252.   REGISTER int pos;
  253.   REGISTER char *p, *end;
  254.   Lisp_Object sym, fun, tem;
  255.   char *name;
  256.  
  257. #ifndef CANNOT_DUMP
  258.   if (!purify_flag)
  259.     error ("Snarf-documentation can only be called in an undumped Emacs");
  260. #endif
  261.  
  262.   CHECK_STRING (filename, 0);
  263.  
  264. #ifndef CANNOT_DUMP
  265.   name = (char *) alloca (string_length (XSTRING (filename)) + 14);
  266.   strcpy (name, "../lib-src/");
  267. #else /* CANNOT_DUMP */
  268.   CHECK_STRING (Vdoc_directory, 0);
  269.   name = (char *) alloca (string_length (XSTRING (filename)) 
  270.                           + string_length (XSTRING (Vdoc_directory))
  271.                           + 1);
  272.   strcpy (name, (char *) string_data (XSTRING (Vdoc_directory)));
  273. #endif /* CANNOT_DUMP */
  274.   strcat (name, (char *) string_data (XSTRING (filename)));
  275. #ifdef VMS
  276. #ifndef VMS4_4
  277.   /* For VMS versions with limited file name syntax,
  278.      convert the name to something VMS will allow.  */
  279.   p = name;
  280.   while (*p)
  281.     {
  282.       if (*p == '-')
  283.     *p = '_';
  284.       p++;
  285.     }
  286. #endif /* not VMS4_4 */
  287. #ifdef VMS4_4
  288.   strcpy (name, sys_translate_unix (name));
  289. #endif /* VMS4_4 */
  290. #endif /* VMS */
  291.  
  292.   fd = open (name, O_RDONLY, 0);
  293.   if (fd < 0)
  294.     report_file_error ("Opening doc string file",
  295.                Fcons (build_string (name), Qnil));
  296.   Vdoc_file_name = filename;
  297.   filled = 0;
  298.   pos = 0;
  299.   while (1)
  300.     {
  301.       if (filled < 512)
  302.     filled += read (fd, &buf[filled], sizeof buf - 1 - filled);
  303.       if (!filled)
  304.     break;
  305.  
  306.       buf[filled] = 0;
  307.       p = buf;
  308.       end = buf + (filled < 512 ? filled : filled - 128);
  309.       while (p != end && *p != '\037') p++;
  310.       /* p points to ^_Ffunctionname\n or ^_Vvarname\n.  */
  311.       if (p != end)
  312.     {
  313.       end = strchr (p, '\n');
  314.       sym = oblookup (Vobarray, (Bufbyte *) p + 2, end - p - 2);
  315.       if (SYMBOLP (sym))
  316.         {
  317.               Lisp_Object offset = make_number (pos + end + 1 - buf);
  318.           /* Attach a docstring to a variable */
  319.           if (p[1] == 'V')
  320.         {
  321.           /* Install file-position as variable-documentation property
  322.              and make it negative for a user-variable
  323.              (doc starts with a `*').  */
  324.           Lisp_Object old = Fget (sym, Qvariable_documentation, Qzero);
  325.                   if (!EQ (old, Qzero))
  326.             {
  327.               weird_doc (sym, GETTEXT ("duplicate"),
  328.                  GETTEXT ("variable"), pos);
  329.               /* In the case of duplicate doc file entries, always
  330.              take the later one.  But if the doc is not an int
  331.              (a string, say) leave it alone. */
  332.               if (!INTP (old))
  333.             goto weird;
  334.             }
  335.           Fput (sym, Qvariable_documentation,
  336.                         ((end[1] == '*') 
  337.                          ? make_number (- XINT (offset))
  338.                          : offset));
  339.         }
  340.           /* Attach a docstring to a function.
  341.                  The type determines where the docstring is stored.  */
  342.           else if (p[1] == 'F')
  343.         {
  344.                   fun = XSYMBOL (sym)->function;/*indirect_function (sym,0);*/
  345.  
  346.           if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
  347.             fun = XCDR (fun);
  348.  
  349.                   if (EQ (fun, Qunbound))
  350.                   {
  351.                     /* May have been #if'ed out or something */
  352.                     weird_doc (sym, GETTEXT ("not fboundp"),
  353.                    GETTEXT ("function"), pos);
  354.                     goto weird;
  355.                   }
  356.           else if (SUBRP (fun))
  357.                   {
  358.                     /* Lisp_Subrs have a slot for it.  */
  359.                     if (XSUBR (fun)->doc)
  360.               {
  361.             weird_doc (sym, GETTEXT ("duplicate"),
  362.                    GETTEXT ("subr"), pos);
  363.             goto weird;
  364.               }
  365.             XSUBR (fun)->doc = (char *) (- XINT (offset));
  366.                   }
  367.           else if (CONSP (fun))
  368.             {
  369.                       /* If it's a lisp form, stick it in the form.  */
  370.               tem = XCAR (fun);
  371.               if (EQ (tem, Qlambda) || EQ (tem, Qautoload))
  372.             {
  373.               tem = Fcdr (Fcdr (fun));
  374.               if (CONSP (tem) &&
  375.                   INTP (XCAR (tem)))
  376.                 {
  377.                   Lisp_Object old = XCAR (tem);
  378.                   if (!EQ (old, Qzero))
  379.                 {
  380.                   weird_doc (sym, GETTEXT ("duplicate"),
  381.                          (EQ (tem, Qlambda)
  382.                           ? GETTEXT ("lambda")
  383.                           : GETTEXT ("autoload")),
  384.                          pos);
  385.                   /* In the case of duplicate doc file entries,
  386.                      always take the later one.  But if the doc
  387.                      is not an int (a string, say) leave it
  388.                      alone. */
  389.                   if (!INTP (old))
  390.                     goto weird;
  391.                 }
  392.                   XCAR (tem) = offset;
  393.                 }
  394.                           else goto weird_function;
  395.                         }
  396.                       else goto weird_function;
  397.             }
  398.           else if (BYTECODEP (fun))
  399.             {
  400.                       /* Bytecode objects sometimes have slots for it.  */
  401.                       struct Lisp_Bytecode *b = XBYTECODE (fun);
  402.  
  403.               /* This bytecode object must have a slot for the
  404.              docstring, since we've found a docstring for it.
  405.                  Unless there were multiple definitions of it, and
  406.              the latter one didn't have any doc, which is a legal
  407.              if slightly bogus situation, so don't blow up. */
  408.  
  409.                       if (! (b->flags.documentationp))
  410.             {
  411.               weird_doc (sym, GETTEXT ("no doc slot"),
  412.                      GETTEXT ("bytecode"), pos);
  413.               goto weird;
  414.             }
  415.               else
  416.             {
  417.               Lisp_Object old = bytecode_documentation (b);
  418.               if (!EQ (old, Qzero))
  419.                 {
  420.                   weird_doc (sym, GETTEXT ("duplicate"),
  421.                      GETTEXT ("bytecode"), pos);
  422.                   /* In the case of duplicate doc file entries,
  423.                  always take the later one.  But if the doc is
  424.                  not an int (a string, say) leave it alone. */
  425.                   if (!INTP (old))
  426.                 goto weird;
  427.                 }
  428.               set_bytecode_documentation (b, offset);
  429.             }
  430.                     }
  431.                   else
  432.                     {
  433.                       /* Otherwise the function is undefined or
  434.                          otherwise weird.   Ignore it. */
  435.                     weird_function:
  436.                       weird_doc (sym, GETTEXT ("weird function"),
  437.                  GETTEXT ("function"), pos);
  438.                       goto weird;
  439.                     }
  440.                 }
  441.           else
  442.                 {
  443.                 /* lose: */
  444.                   error ("DOC file invalid at position %d", pos);
  445.                 weird:
  446.                   /* goto lose */;
  447.                 }
  448.             }
  449.     }
  450.       pos += end - buf;
  451.       filled -= end - buf;
  452.       memmove (buf, end, filled);
  453.     }
  454.   close (fd);
  455.   return Qnil;
  456. }
  457.  
  458.  
  459. #if 1    /* Don't warn about functions whose doc was lost because they were
  460.        wrapped by advice-freeze.el... */
  461. static int
  462. kludgily_ignore_lost_doc_p (Lisp_Object sym)
  463. {
  464. # define kludge_prefix "ad-Orig-"
  465.   return (string_length (XSYMBOL (sym)->name) > sizeof (kludge_prefix) &&
  466.       !strncmp ((char *) string_data (XSYMBOL (sym)->name), kludge_prefix,
  467.             sizeof (kludge_prefix) - 1));
  468. # undef kludge_prefix
  469. }
  470. #else
  471. # define kludgily_ignore_lost_doc_p(sym) 0
  472. #endif
  473.  
  474.  
  475. static void
  476. verify_doc_mapper (Lisp_Object sym, Lisp_Object closure)
  477. {
  478.   if (!NILP (Ffboundp (sym)))
  479.     {
  480.       int doc = 0;
  481.       Lisp_Object fun = XSYMBOL (sym)->function;
  482.       if (CONSP (fun) &&
  483.       EQ (XCAR (fun), Qmacro))
  484.     fun = XCDR (fun);
  485.  
  486.       if (SUBRP (fun))
  487.     doc = (LISP_WORD_TYPE) XSUBR (fun)->doc;
  488.       else if (SYMBOLP (fun))
  489.     doc = -1;
  490.       else if (KEYMAPP (fun))
  491.     doc = -1;
  492.       else if (CONSP (fun))
  493.     {
  494.       Lisp_Object tem = XCAR (fun);
  495.       if (EQ (tem, Qlambda) || EQ (tem, Qautoload))
  496.         {
  497.           doc = -1;
  498.           tem = Fcdr (Fcdr (fun));
  499.           if (CONSP (tem) &&
  500.           INTP (XCAR (tem)))          
  501.         doc = XINT (XCAR (tem));
  502.         }
  503.     }
  504.       else if (BYTECODEP (fun))
  505.     {
  506.           struct Lisp_Bytecode *b = XBYTECODE (fun);
  507.           if (! (b->flags.documentationp))
  508.             doc = -1;
  509.           else
  510.             {
  511.               Lisp_Object tem = bytecode_documentation (b);
  512.               if (INTP (tem))
  513.                 doc = XINT (tem);
  514.             }
  515.     }
  516.  
  517.       if (doc == 0 && !kludgily_ignore_lost_doc_p (sym))
  518.     {
  519.       message ("Warning: doc lost for function %s.",
  520.            string_data (XSYMBOL (sym)->name));
  521.       XCDR (closure) = Qt;
  522.     }
  523.     }
  524.   if (!NILP (Fboundp (sym)))
  525.     {
  526.       Lisp_Object doc = Fget (sym, Qvariable_documentation, Qnil);
  527.       if (EQ (doc, Qzero))
  528.     {
  529.       message ("Warning: doc lost for variable %s.",
  530.            string_data (XSYMBOL (sym)->name));
  531.       XCDR (closure) = Qt;
  532.     }
  533.     }
  534. }
  535.  
  536. DEFUN ("Verify-documentation", Fverify_documentation, Sverify_documentation,
  537.        0, 0, 0,
  538.        "Used to make sure everything went well with Snarf-documentation.\n\
  539. Writes to stderr if not.")
  540.      ()
  541. {
  542.   Lisp_Object closure = Fcons (Qnil, Qnil);
  543.   struct gcpro gcpro1;
  544.   GCPRO1 (closure);
  545.   map_obarray (Vobarray, verify_doc_mapper, closure);
  546.   if (!NILP (Fcdr (closure)))
  547.     message ("\n\
  548. This is usually because some files were preloaded by loaddefs.el or\n\
  549. site-load.el, but were not passed to make-docfile by Makefile.\n");
  550.   UNGCPRO;
  551.   return (NILP (Fcdr (closure)) ? Qt : Qnil);
  552. }
  553.  
  554.  
  555. DEFUN ("substitute-command-keys", Fsubstitute_command_keys,
  556.   Ssubstitute_command_keys, 1, 1, 0,
  557.   "Substitute key descriptions for command names in STRING.\n\
  558. Return a new string which is STRING with substrings of the form \\=\\[COMMAND]\n\
  559. replaced by either:  a keystroke sequence that will invoke COMMAND,\n\
  560. or \"M-x COMMAND\" if COMMAND is not on any keys.\n\
  561. Substrings of the form \\=\\{MAPVAR} are replaced by summaries\n\
  562. \(made by describe-bindings) of the value of MAPVAR, taken as a keymap.\n\
  563. Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR\n\
  564. as the keymap for future \\=\\[COMMAND] substrings.\n\
  565. \\=\\= quotes the following character and is discarded;\n\
  566. thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.")
  567.   (str)
  568.      Lisp_Object str;
  569. {
  570.   /* This function can GC */
  571.   Bufbyte *buf;
  572.   int changed = 0;
  573.   REGISTER Bufbyte *strdata;
  574.   REGISTER Bufbyte *bufp;
  575.   Bytecount strlength;
  576.   Bytecount idx;
  577.   Bytecount bsize;
  578.   Bufbyte *new;
  579.   Lisp_Object tem = Qnil;
  580.   Lisp_Object keymap;
  581.   Bufbyte *start;
  582.   Bytecount length;
  583.   Lisp_Object name;
  584.   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
  585.  
  586.   if (NILP (str))
  587.     return Qnil;
  588.  
  589.   CHECK_STRING (str, 0);
  590.   tem = Qnil;
  591.   keymap = Qnil;
  592.   name = Qnil;
  593.   GCPRO4 (str, tem, keymap, name);
  594.  
  595.   /* There is the possibility that the string is not destined for a
  596.      translating stream, and it could be argued that we should do the
  597.      same thing here as in Fformat(), but there are very few times
  598.      when this will be the case and many calls to this function
  599.      would have to have `gettext' calls added. (I18N3) */
  600.   str = LISP_GETTEXT (str);
  601.   /* KEYMAP is either nil (which means search all the active keymaps)
  602.      or a specified local map from a \\<mapname> construct (which means
  603.      search just that and the global map). */
  604.  
  605.   strlength = string_length (XSTRING (str));
  606.   bsize = strlength;
  607.   buf = (Bufbyte *) xmalloc (bsize);
  608.   bufp = buf;
  609.  
  610.   /* Have to reset strdata every time GC might be called */
  611.   strdata = string_data (XSTRING (str));
  612.   for (idx = 0; idx < strlength; )
  613.     {
  614.       Bufbyte *strp = strdata + idx;
  615.   
  616.       if (strp[0] != '\\')
  617.     {
  618.       /* just copy other chars */
  619.       *bufp++ = *strp;
  620.       idx++;
  621.     }
  622.       else switch (strp[1])
  623.     {
  624.     default:
  625.       {
  626.         /* just copy unknown escape sequences */
  627.         *bufp++ = *strp;
  628.         idx++;
  629.         break;
  630.       }
  631.     case '=':
  632.       {
  633.         /* \= quotes the next character;
  634.            thus, to put in \[ without its special meaning, use \=\[.  */
  635.         changed = 1;
  636.         *bufp++ = strp[2];
  637.         idx += 3;
  638.         break;
  639.       }
  640.     case '[':
  641.       {
  642.         changed = 1;
  643.         idx += 2;        /* skip \[ */
  644.         strp += 2;
  645.         start = strp;
  646.  
  647.         while ((idx < strlength)
  648.            && *strp != ']')
  649.           { 
  650.         strp++; 
  651.         idx++; 
  652.           }
  653.         length = strp - start;
  654.         idx++;        /* skip ] */
  655.  
  656.         tem = Fintern (make_string (start, length), Qnil);
  657.         tem = Fwhere_is_internal (tem, keymap, Qt, Qnil, Qnil);
  658.  
  659.         if (NILP (tem))    /* but not on any keys */
  660.           {
  661.         new = (Bufbyte *) xrealloc (buf, bsize += 4);
  662.         bufp += new - buf;
  663.         buf = new;
  664.         memcpy (bufp, "M-x ", 4);
  665.         bufp += 4;
  666.         goto subst;
  667.           }
  668.         else
  669.           {            /* function is on a key */
  670.         tem = Fkey_description (tem);
  671.         goto subst_string;
  672.           }
  673.       }
  674.     case '{':
  675.     case '<':
  676.       {
  677.         /* \{foo} is replaced with a summary of keymap (symbol-value foo).
  678.            \<foo> just sets the keymap used for \[cmd].  */
  679.         struct buffer *oldbuf;
  680.  
  681.         changed = 1;
  682.         idx += 2;        /* skip \{ or \< */
  683.         strp += 2;
  684.         start = strp;
  685.  
  686.         while ((idx < strlength)
  687.            && *strp != '}' && *strp != '>')
  688.           { 
  689.         strp++; 
  690.         idx++; 
  691.           }
  692.         length = strp - start;
  693.         idx++;        /* skip } or > */
  694.  
  695.         /* Get the value of the keymap in TEM, or nil if undefined.
  696.            Do this while still in the user's current buffer
  697.            in case it is a local variable.  */
  698.         name = Fintern (make_string (start, length), Qnil);
  699.         tem = Fboundp (name);
  700.         if (! NILP (tem))
  701.           {
  702.         tem = Fsymbol_value (name);
  703.         if (! NILP (tem))
  704.           tem = get_keymap (tem, 0, 1);
  705.           }
  706.  
  707.         /* Now switch to a temp buffer.  */
  708.         oldbuf = current_buffer;
  709.         set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
  710.  
  711.         if (NILP (tem))
  712.           {
  713.         char buf[255], *b = buf;
  714.         *b++ = '\n';
  715.         sprintf (b, GETTEXT (
  716.         "Uses keymap \"%s\", which is not currently defined."),
  717.              (char *) string_data (XSTRING (Fsymbol_name (name))));
  718.         b += strlen (b);
  719.         *b++ = '\n';
  720.         *b++ = 0;
  721.         buffer_insert_c_string (current_buffer, buf);
  722.  
  723.         if (start[-1] == '<') keymap = Qnil;
  724.           }
  725.         else if (start[-1] == '<')
  726.           keymap = tem;
  727.         else
  728.           describe_map_tree (tem, 1, Qnil, Qnil, 0);
  729.         tem = Fbuffer_substring (Qnil, Qnil, Fcurrent_buffer ());
  730.         Ferase_buffer (Fcurrent_buffer ());
  731.         set_buffer_internal (oldbuf);
  732.         goto subst_string;
  733.  
  734.       subst_string:
  735.         start = string_data (XSTRING (tem));
  736.         length = string_length (XSTRING (tem));
  737.       subst:
  738.         bsize += length;
  739.         new = (Bufbyte *) xrealloc (buf, bsize);
  740.         bufp += new - buf;
  741.         buf = new;
  742.         memcpy (bufp, start, length);
  743.         bufp += length;
  744.  
  745.         /* Reset STRDATA in case gc relocated it.  */
  746.         strdata = string_data (XSTRING (str));
  747.  
  748.         break;
  749.       }
  750.     }
  751.     }
  752.  
  753.   if (changed)            /* don't bother if nothing substituted */
  754.     tem = make_string (buf, bufp - buf);
  755.   else
  756.     tem = str;
  757.   xfree (buf);
  758.   UNGCPRO;
  759.   return (tem);
  760. }
  761.  
  762.  
  763. /************************************************************************/
  764. /*                            initialization                            */
  765. /************************************************************************/
  766.  
  767. void
  768. syms_of_doc (void)
  769. {
  770.   defsubr (&Sdocumentation);
  771.   defsubr (&Sdocumentation_property);
  772.   defsubr (&Ssnarf_documentation);
  773.   defsubr (&Sverify_documentation);
  774.   defsubr (&Ssubstitute_command_keys);
  775. }
  776.  
  777. void
  778. vars_of_doc (void)
  779. {
  780.   DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name,
  781.     "Name of file containing documentation strings of built-in symbols.");
  782.   Vdoc_file_name = Qnil;
  783. }
  784.